import requests
from bs4 import BeautifulSoup
import pandas as pd
import time
from datetime import datetime
import os
import re

def get_url_links_val(url, contain_keyword="", filter_text="About us", save_txt=True):
    """
    爬取链接中带爬取指定URL中的所有链接及其文本内容，可以根据关键词过滤链接
    
    Args:
        url (str): 要爬取的URL
        contain_keyword (str): 用于过滤链接的关键词，默认为空字符串
        filter_text (str): 要过滤掉的文本内容，默认为'About us'
        save_txt (bool): 是否保存结果为txt文件，默认为True
        
    Returns:
        list: 包含[链接列表, 文本列表]的列表
    """
    # 存储链接和文本内容的列表
    links = []
    texts = []
    
    # 设置请求头，模拟浏览器访问
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
    }
    
    try:
        # 发送GET请求
        response = requests.get(url, headers=headers, timeout=10)
        response.encoding = 'utf-8'
        
        # 使用BeautifulSoup解析HTML
        soup = BeautifulSoup(response.text, 'html.parser')
        
        # 查找所有a标签
        a_tags = soup.find_all('a')
        
        # 遍历并提取链接和文本内容
        for a_tag in a_tags:
            href = a_tag.get('href')
            if href:
                # 获取链接文本内容
                text = a_tag.get_text().strip()
                
                # 跳过指定的过滤文本
                if text == filter_text:
                    continue
                
                # 处理不同类型的URL
                if href.startswith('//'):
                    # 处理以//开头的URL（协议相对URL）
                    full_url = 'https:' + href
                elif href.startswith('/'):
                    # 处理以/开头的相对URL
                    if url.endswith('/'):
                        full_url = url[:-1] + href
                    else:
                        full_url = url + href
                elif href.startswith('http'):
                    # 绝对URL直接添加
                    full_url = href
                else:
                    # 其他相对路径
                    if url.endswith('/'):
                        full_url = url + href
                    else:
                        full_url = url + '/' + href
                
                # 只添加包含过滤关键词的链接
                if contain_keyword in full_url:
                    links.append(full_url)
                    texts.append(text)
        
        # 如果需要保存结果到txt文件且有获取到链接
        if save_txt and links:
            # 从URL生成文件名
            url_part = url.replace('http://', '').replace('https://', '').replace('www.', '')
            for char in ['\\', '/', ':', '*', '?', '"', '<', '>', '|', ' ', '.']:
                url_part = url_part.replace(char, '_')
            url_part = url_part[:50]  # 限制长度
            output_file = f"links_{url_part}.txt"
            
            # 保存到文件
            list2txt([links, texts], output_file)
            print(f"已将链接保存到文件: {output_file}")
            
        return [links, texts]
        
    except Exception as e:
        print(f'获取链接时发生错误: {str(e)}')
        return [[], []]

def get_url_list_links_val(url_list, contain_keyword="", filter_text="About us", save_txt=True):
    """
    批量爬取多个URL中的链接及其文本内容
    
    Args:
        url_list (list): 要爬取的URL列表
        contain_keyword (str): 用于过滤链接的关键词，默认为空字符串
        filter_text (str): 要过滤掉的文本内容，默认为'About us'
        save_txt (bool): 是否保存结果为txt文件，默认为True
        
    Returns:
        list: 包含[链接列表, 文本列表]的列表
    """
    # 存储所有链接和文本内容的列表
    all_links = []
    all_texts = []
    
    # 遍历URL列表
    for url in url_list:
        print(f"正在爬取: {url}")
        
        # 调用单个URL爬取函数（不单独保存每个URL的结果）
        result = get_url_links_val(url, contain_keyword, filter_text, save_txt=False)
        
        # 合并结果
        all_links.extend(result[0])
        all_texts.extend(result[1])
        
        # 添加延时，避免请求过于频繁
        time.sleep(2)
    
    print(f"批量爬取完成，共获取 {len(all_links)} 个链接")
    
    # 如果需要保存结果到txt文件且有获取到链接
    if save_txt and all_links:
        # 生成带时间戳的文件名
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        output_file = f"batch_links_{timestamp}.txt"
        
        # 保存到文件
        list2txt([all_links, all_texts], output_file)
        print(f"已将批量爬取结果保存到文件: {output_file}")
    
    return [all_links, all_texts]


def list2txt(data, output_file="links_data.txt", delimiter="\t"):
    """
    将链接列表和文本列表保存为两列的文本文件
    
    Args:
        data (list): 包含[链接列表, 文本列表]的列表
        output_file (str): 输出文件名，默认为'links_data.txt'
        delimiter (str): 列之间的分隔符，默认为制表符
        
    Returns:
        bool: 保存成功返回True，否则返回False
    """
    links = data[0]
    texts = data[1]
    
    try:
        # 确保两个列表长度一致
        if len(links) != len(texts):
            print("错误：链接列表和文本列表长度不一致")
            return False
            
        # 写入文件
        with open(output_file, 'w', encoding='utf-8') as f:
            # 写入标题行
            f.write(f"链接{delimiter}文本内容\n")
            
            # 写入数据行
            for i in range(len(links)):
                f.write(f"{links[i]}{delimiter}{texts[i]}\n")
                
        print(f"数据已成功保存到 {output_file}，共 {len(links)} 条记录")
        return True
        
    except Exception as e:
        print(f"保存文件时发生错误: {str(e)}")
        return False

def generate_url_list(start_page, end_page, url_template):
    """
    根据页码范围和URL模板生成URL列表[左闭，右闭]（注意：包含end_page）
    
    Args:
        start_page (int): 起始页码
        end_page (int): 结束页码
        url_template (str): URL模板，包含"{}"作为页码占位符
        
    Returns:
        list: 生成的URL列表
    """
    url_list = []
    
    for i in range(start_page, end_page + 1):
        # 使用格式化字符串生成URL
        url = url_template.format(i)
        url_list.append(url)
    
    print(f"已生成 {len(url_list)} 个URL")
    return url_list

    
def txtcol2emptyfile(input_file="gov_law_links.txt", output_folder="temp", filter_text="About us", select_col=1, prefix=""):
    """
    空文本生成器（根据指定列-第2列）-过滤指定文本内容；
    根据指定列的内容为每个不同的值创建一个空文本文件，可以过滤掉指定文本内容
    
    Args:
        input_file (str): 输入文件名，默认为'gov_law_links.txt'
        output_folder (str): 输出文件夹，默认为'temp'
        filter_text (str): 要过滤的文本内容，默认为'About us'
        select_col (int): 要选择的列索引，默认为1（第2列）
        prefix (str): 文件名前缀，默认为空字符串
        
    Returns:
        int: 创建的文件数量
    """
    try:
        # 确保输出文件夹存在
        if not os.path.exists(output_folder):
            os.makedirs(output_folder)
            print(f"已创建文件夹: {output_folder}")
        
        # 读取输入文件
        with open(input_file, 'r', encoding='utf-8') as f:
            lines = f.readlines()
        
        # 跳过标题行
        data_lines = lines[1:] if len(lines) > 0 else []
        
        # 创建文件计数
        file_count = 0
        created_files = set()
        
        # 为每个不同的列值创建一个空文件
        for line in data_lines:
            parts = line.strip().split('\t')
            if len(parts) > select_col:
                col_value = parts[select_col]
                
                # 跳过指定的过滤文本
                if col_value == filter_text:
                    continue
                
                # 创建文件名，替换不允许在文件名中使用的字符
                file_name = col_value
                for char in ['\\', '/', ':', '*', '?', '"', '<', '>', '|']:
                    file_name = file_name.replace(char, '_')
                
                # 添加前缀到文件名
                file_name_with_prefix = f"{prefix}{file_name}"
                
                # 完整的文件路径
                file_path = os.path.join(output_folder, f"{file_name_with_prefix}.txt")
                
                # 如果文件名不在已创建的集合中，则创建文件
                if file_name not in created_files:
                    with open(file_path, 'w', encoding='utf-8') as f:
                        pass  # 创建空文件
                    
                    created_files.add(file_name)
                    file_count += 1
        
        print(f"已根据第{select_col+1}列内容创建 {file_count} 个空文件，保存在: {output_folder}")
        if prefix:
            print(f"文件名前缀: {prefix}")
        return file_count
        
    except Exception as e:
        print(f"创建文件时发生错误: {str(e)}")
        return 0

def link2txt(url, output_file=None, output_folder="temp", file_name="", file_name_add_url=True):
    """
    提取URL的正文内容并保存到文本文件中
    
    Args:
        url (str): 要提取内容的URL
        output_file (str): 输出文件名，默认为None（自动生成）
        output_folder (str): 输出文件夹，默认为'temp'
        file_name (str): 文件名前缀，默认为空字符串
        file_name_add_url (bool): 是否在文件名后添加URL，默认为True
        
    Returns:
        str: 提取的正文内容
    """
    try:
        # 确保输出文件夹存在
        if not os.path.exists(output_folder):
            os.makedirs(output_folder)
            print(f"已创建文件夹: {output_folder}")
        
        # 设置请求头，模拟浏览器访问
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
        }
        
        # 发送GET请求
        print(f"正在获取URL内容: {url}")
        response = requests.get(url, headers=headers, timeout=15)
        response.encoding = 'utf-8'
        
        # 使用BeautifulSoup解析HTML
        soup = BeautifulSoup(response.text, 'html.parser')
        
        # 提取标题
        title = ""
        title_tag = soup.find('title')
        if title_tag:
            title = title_tag.get_text().strip()
        
        # 尝试提取更新日期
        update_date = ""
        
        # 尝试找到adio类的div，这通常包含更新日期
        date_divs = soup.find_all('div', class_='adio')
        for div in date_divs:
            # 检查div中是否包含"Updated"文本
            if "Updated" in div.text:
                # 获取所有文本内容并清理
                update_text = div.get_text().strip()
                # 去除多余空格
                update_text = ' '.join(update_text.split())
                update_date = update_text
                break
        
        # 提取正文内容
        content = ""
        
        # 尝试找到内容区域
        content_div = soup.find('div', id='sp')
        if content_div:
            # 提取所有段落文本
            paragraphs = content_div.find_all('p')
            content_parts = []
            for p in paragraphs:
                text = p.get_text().strip()
                if text:  # 只添加非空段落
                    content_parts.append(text)
            content = "\n".join(content_parts)  # 使用单个换行符连接段落
        else:
            # 如果找不到特定的内容区域，尝试其他方法
            all_paragraphs = soup.find_all('p')
            content_parts = []
            for p in all_paragraphs:
                text = p.get_text().strip()
                if text and len(text) > 50:  # 只添加有意义的段落
                    content_parts.append(text)
            content = "\n".join(content_parts)  # 使用单个换行符连接段落
        
        # 处理文件名
        if output_file is None:
            # 处理基本文件名
            if file_name:
                # 使用提供的文件名前缀
                base_name = file_name
            else:
                # 使用标题作为文件名前缀
                base_name = title if title else "content"
            
            # 清理基本文件名，替换不允许的字符
            for char in ['\\', '/', ':', '*', '?', '"', '<', '>', '|']:
                base_name = base_name.replace(char, '_')
            # 限制长度
            base_name = base_name[:50]
            
            # 是否添加URL到文件名
            if file_name_add_url:
                # 处理URL作为文件名的一部分
                url_part = url
                # 替换URL中的特殊字符
                url_part = url_part.replace('http://', '')
                url_part = url_part.replace('https://', '')
                url_part = url_part.replace('www.', '')
                # 替换所有不允许在文件名中使用的字符
                for char in ['\\', '/', ':', '*', '?', '"', '<', '>', '|', ' ', '.', '&', '=', '%']:
                    url_part = url_part.replace(char, '_')
                # 限制URL部分的长度
                url_part = url_part[:50]
                
                output_file = f"{base_name}_{url_part}.txt"
            else:
                output_file = f"{base_name}.txt"
        
        # 完整的输出文件路径
        output_path = os.path.join(output_folder, output_file)
        
        # 保存内容到文件
        with open(output_path, 'w', encoding='utf-8') as f:
            # 写入标题
            if title:
                f.write(f"{title}\n")
            
            # 写入更新日期（如果有）
            if update_date:
                f.write(f"{update_date}\n")
            
            # 写入正文（如果标题或日期存在，添加一个空行分隔）
            if title or update_date:
                f.write("\n")
            f.write(content)
        
        print(f"已提取内容并保存到: {output_path}")
        return content
        
    except Exception as e:
        print(f"提取内容时发生错误: {str(e)}")
        return ""


def test_get_links():
    """
    测试get_url_links_val函数
    """
    # 指定测试URL
    test_url = "https://english.www.gov.cn/archive/lawsregulations/page_1.html"
    
    # 调用函数获取链接，可以添加过滤关键词和过滤文本
    links_data = get_url_links_val(test_url, contain_keyword="content", filter_text="About us")
    links = links_data[0]
    texts = links_data[1]
    
    # 打印链接数量
    print(f"共获取到 {len(links)} 个链接")
    
    # 打印前10个链接和文本内容
    print("前10个链接及内容:")
    for i in range(min(15, len(links))):
        print(f"{i+1}. 链接: {links[i]}")
        print(f"   文本: {texts[i]}")
        print("---")
    
    # 保存链接和文本到文件
    list2txt(links_data, "gov_links.txt")

def test_link2txt():
    """
    测试link2txt函数，提取URL的正文内容
    """
    # 测试URL
    test_url = "https://english.www.gov.cn/archive/lawsregulations/201608/26/content_WS5d148be0c6d02a31718376b6.html"
    
    # 测试1：使用默认参数（文件名添加URL）
    print("测试1：使用默认参数（文件名添加URL）")
    content1 = link2txt(test_url, output_folder="law_content")
    
    # # 测试2：使用自定义文件名前缀，添加URL
    # print("\n测试2：使用自定义文件名前缀，添加URL")
    # content2 = link2txt(test_url, output_folder="law_content", file_name="进出口商品检验法")
    
    # # 测试3：使用自定义文件名前缀，不添加URL
    # print("\n测试3：使用自定义文件名前缀，不添加URL")
    # content3 = link2txt(test_url, output_folder="law_content", file_name="进出口商品检验法", file_name_add_url=False)
    
    # 打印提取的内容长度
    if content1:
        print(f"成功提取内容，长度: {len(content1)} 字符")
    else:
        print("提取内容失败")

def extract_links_from_markdown(md_file_path, col_index=2, class_name="paper-pdf", tag_name="a", attr_name="href", 
                              append_to_file=True, save_to_csv=True, output_csv_file="extracted_links.csv"):
    """
    从Markdown文件中提取指定列的超链接，并获取目标网页中指定元素的属性值
    
    Args:
        md_file_path (str): Markdown文件路径
        col_index (int): 要提取链接的列索引，默认为2（第三列，标题列）
        class_name (str): 要查找的CSS类名，默认为"paper-pdf"
        tag_name (str): 要查找的HTML标签名，默认为"a"
        attr_name (str): 要获取的标签属性名，默认为"href"
        append_to_file (bool): 是否追加链接到原Markdown文件，默认为True
        save_to_csv (bool): 是否保存结果到CSV文件，默认为True
        output_csv_file (str): 输出CSV文件名，默认为"extracted_links.csv"
        
    Returns:
        list: 包含[标题, 原始链接, 属性值]的列表
    """
    import re
    
    results = []
    
    try:
        # 读取Markdown文件
        with open(md_file_path, 'r', encoding='utf-8') as f:
            content = f.read()
        
        # 将Markdown表格转换为行列表
        lines = content.strip().split('\n')
        
        # 跳过表头行（通常是前2行）
        data_lines = lines[2:] if len(lines) > 2 else []
        
        # 提取每行中指定列的链接
        for line in data_lines:
            # 移除行首行尾的管道符号并分割
            cells = line.strip('| ').split(' | ')
            
            # 确保有足够的列
            if len(cells) > col_index:
                cell_content = cells[col_index].strip()
                
                # 使用正则表达式匹配Markdown链接格式：[title](url)
                pattern = r'\[([^\]]+)\]\(([^)]+)\)'
                matches = re.findall(pattern, cell_content)
                
                # 处理匹配到的链接
                for title, url in matches:
                    print(f"正在处理: {title}")
                    print(f"原始链接: {url}")
                    
                    # 设置请求头，模拟浏览器访问
                    headers = {
                        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
                    }
                    
                    try:
                        # 访问链接页面
                        response = requests.get(url, headers=headers, timeout=10)
                        response.encoding = 'utf-8'
                        
                        # 使用BeautifulSoup解析HTML
                        soup = BeautifulSoup(response.text, 'html.parser')
                        
                        # 根据参数查找元素
                        if class_name:
                            # 查找指定CSS类名的元素
                            target_element = soup.find('div', class_=class_name)
                        else:
                            # 如果没有指定类名，则从整个文档开始查找
                            target_element = soup
                        
                        if target_element:
                            # 查找指定标签
                            if tag_name:
                                target_tag = target_element.find(tag_name)
                            else:
                                # 如果没有指定标签名，则使用元素本身
                                target_tag = target_element
                            
                            if target_tag:
                                # 获取指定属性
                                attr_value = target_tag.get(attr_name) if attr_name else None
                                if attr_value:
                                    print(f"找到{attr_name}属性: {attr_value}")
                                    results.append([title, url, attr_value])
                                else:
                                    print(f"未找到{attr_name}属性")
                                    results.append([title, url, ""])
                            else:
                                print(f"未找到{tag_name}标签")
                                results.append([title, url, ""])
                        else:
                            print(f"未找到包含{class_name}类名的元素")
                            results.append([title, url, ""])
                            
                    except Exception as e:
                        print(f'访问链接时发生错误: {str(e)}')
                        results.append([title, url, ""])
                        
                    # 添加延时，避免请求过于频繁
                    time.sleep(1)
            
        # 默认追加链接到原Markdown文件
        if append_to_file and results:
            append_links_to_markdown(md_file_path, col_index=col_index, class_name=class_name, 
                                   tag_name=tag_name, attr_name=attr_name)
            
        # 默认保存结果到CSV文件
        if save_to_csv and results:
            save_pdf_links_to_csv(results, output_csv_file)
            
        return results
        
    except Exception as e:
        print(f'读取Markdown文件时发生错误: {str(e)}')
        return []

def extract_pdf_links_from_markdown(md_file_path, append_to_file=True, save_to_csv=True, output_csv_file="pdf_links.csv"):
    """
    从Markdown文件中提取超链接并获取PDF链接（保持向后兼容）
    
    Args:
        md_file_path (str): Markdown文件路径
        append_to_file (bool): 是否追加链接到原Markdown文件
        save_to_csv (bool): 是否保存结果到CSV文件
        output_csv_file (str): 输出CSV文件名
        
    Returns:
        list: 包含[标题, 原始链接, PDF链接]的列表
    """
    # 调用通用函数，使用默认参数
    return extract_links_from_markdown(md_file_path, col_index=2, class_name="paper-pdf", tag_name="a", attr_name="href",
                                     append_to_file=append_to_file, save_to_csv=save_to_csv, output_csv_file=output_csv_file)

def test_extract_links(md_file_path="md_files_multi-links/RSS-2026.md", col_index=2, 
                      class_name="paper-pdf", tag_name="a", attr_name="href",
                      append_to_file=True, save_to_csv=True, output_csv_file="rss_2026_links.csv"):
    """
    测试extract_links_from_markdown函数
    
    Args:
        md_file_path (str): Markdown文件路径
        col_index (int): 要提取链接的列索引
        class_name (str): 要查找的CSS类名
        tag_name (str): 要查找的HTML标签名
        attr_name (str): 要获取的标签属性名
        append_to_file (bool): 是否追加链接到原Markdown文件
        save_to_csv (bool): 是否保存结果到CSV文件
        output_csv_file (str): 输出CSV文件名
    """
    
    # 使用正确的列索引（第三列，索引为2，包含标题和链接）
    results = extract_links_from_markdown(md_file_path, col_index=col_index, 
                                        class_name=class_name, tag_name=tag_name, attr_name=attr_name,
                                        append_to_file=append_to_file, save_to_csv=save_to_csv, 
                                        output_csv_file=output_csv_file)
    
    # 打印结果
    print("\n提取结果:")
    for i, (title, original_url, attr_value) in enumerate(results):
        print(f"{i+1}. 标题: {title}")
        print(f"   原始链接: {original_url}")
        print(f"   属性值: {attr_value}")
        print("---")

def test_extract_pdf_links(md_file_path="md_files_multi-links/RSS-2026.md", 
                         append_to_file=True, save_to_csv=True, output_csv_file="rss_2026_pdf_links.csv"):
    """
    测试extract_pdf_links_from_markdown函数
    
    Args:
        md_file_path (str): Markdown文件路径
        append_to_file (bool): 是否追加链接到原Markdown文件
        save_to_csv (bool): 是否保存结果到CSV文件
        output_csv_file (str): 输出CSV文件名
    """
    results = extract_pdf_links_from_markdown(md_file_path)
    
    # 打印结果
    print("\n提取结果:")
    for i, (title, original_url, pdf_url) in enumerate(results):
        print(f"{i+1}. 标题: {title}")
        print(f"   原始链接: {original_url}")
        print(f"   PDF链接: {pdf_url}")
        print("---")
    
    # 保存结果到CSV文件
    if results and save_to_csv:
        save_pdf_links_to_csv(results, output_csv_file)

def save_pdf_links_to_csv(data, output_file="pdf_links.csv"):
    """
    将PDF链接数据保存为CSV文件
    
    Args:
        data (list): 包含[标题, 原始链接, PDF链接]的列表
        output_file (str): 输出文件名
        
    Returns:
        bool: 保存成功返回True，否则返回False
    """
    try:
        # 创建DataFrame
        df = pd.DataFrame(data, columns=['标题', '原始链接', 'PDF链接'])
        
        # 保存为CSV文件
        df.to_csv(output_file, index=False, encoding='utf-8-sig')
        print(f"数据已成功保存到 {output_file}，共 {len(data)} 条记录")
        return True
        
    except Exception as e:
        print(f"保存CSV文件时发生错误: {str(e)}")
        return False

def append_links_to_markdown(md_file_path, output_file_path=None, col_index=2, class_name="paper-pdf", tag_name="a", attr_name="href"):
    """
    从Markdown文件中提取PDF链接并追加到原文件的最后一列
    
    Args:
        md_file_path (str): 输入的Markdown文件路径
        output_file_path (str): 输出的Markdown文件路径，默认为None（覆盖原文件）
        col_index (int): 要提取链接的列索引
        class_name (str): 要查找的CSS类名
        tag_name (str): 要查找的HTML标签名
        attr_name (str): 要获取的标签属性名
        
    Returns:
        bool: 成功返回True，否则返回False
    """
    try:
        # 提取链接
        results = extract_links_from_markdown(md_file_path, col_index=col_index, class_name=class_name, 
                                           tag_name=tag_name, attr_name=attr_name, 
                                           append_to_file=False, save_to_csv=False)
        
        # 创建一个字典以便快速查找
        link_dict = {}
        for title, original_url, pdf_url in results:
            link_dict[original_url] = pdf_url
        
        # 读取原文件内容
        with open(md_file_path, 'r', encoding='utf-8') as f:
            lines = f.readlines()
        
        # 修改表头，添加新的一列
        if len(lines) > 0:
            header = lines[0].rstrip('\n')
            # 检查是否已经有PDF链接列
            if "| PDF Link" not in header:
                # 添加PDF链接列到表头，确保格式正确
                if header.endswith('|'):
                    lines[0] = header + " PDF Link |\n"
                else:
                    lines[0] = header + " | PDF Link |\n"
                    
                # 更新分隔行
                if len(lines) > 1:
                    separator = lines[1].rstrip('\n')
                    if separator.endswith('|'):
                        lines[1] = separator + " :--- |\n"
                    else:
                        lines[1] = separator + " | :--- |\n"
        
        # 处理数据行
        for i in range(2, len(lines)):
            line = lines[i]
            # 解析每一行的单元格
            # 移除行尾的换行符和可能的空格
            line_stripped = line.rstrip('\n')
            
            # 检查该行是否已经有PDF链接列
            # 通过计算管道符号数量来判断
            pipe_count = line_stripped.count('|')
            
            # 正确的单元格数量应该是管道符号数量-1
            expected_cells = pipe_count - 1
            
            # 如果这一行已经有正确的列数，说明已经添加过PDF链接列
            # 原始表格应该有4列（ID, Session, Title, Authors），所以有5个管道符号
            if pipe_count > 5:  # 已经有PDF链接列
                continue
            
            # 分割单元格
            cells = line_stripped.strip().strip('|').split(' | ')
            
            # 确保有足够的列
            if len(cells) >= 3:
                # 提取第三列（标题列）中的链接
                title_cell = cells[2].strip()
                
                # 使用正则表达式匹配Markdown链接格式：[title](url)
                pattern = r'\[([^\]]+)\]\(([^)]+)\)'
                matches = re.findall(pattern, title_cell)
                
                # 如果找到了链接
                if matches:
                    original_url = matches[0][1]  # 获取第一个匹配的URL
                    
                    # 查找对应的PDF链接
                    pdf_url = link_dict.get(original_url, "")
                    
                    # 添加PDF链接列
                    if pdf_url:
                        # 添加PDF链接列
                        if line_stripped.endswith('|'):
                            lines[i] = line_stripped + f" [PDF]({pdf_url}) |\n"
                        else:
                            lines[i] = line_stripped + f" | [PDF]({pdf_url}) |\n"
                    else:
                        # 添加空的PDF链接列
                        if line_stripped.endswith('|'):
                            lines[i] = line_stripped + "  |\n"
                        else:
                            lines[i] = line_stripped + " |  |\n"
        
        # 确定输出文件路径
        if output_file_path is None:
            output_file_path = md_file_path
            
        # 写入修改后的内容
        with open(output_file_path, 'w', encoding='utf-8') as f:
            f.writelines(lines)
            
        print(f"已将PDF链接追加到 {output_file_path}")
        return True
        
    except Exception as e:
        print(f'追加链接到Markdown文件时发生错误: {str(e)}')
        return False

def test_append_links(md_file_path="md_files_multi-links/RSS-2026.md", output_file_path="md_files_multi-links/RSS-2026_updated_fixed.md",
                    col_index=2, class_name="paper-pdf", tag_name="a", attr_name="href"):
    """
    测试append_links_to_markdown函数
    
    Args:
        md_file_path (str): Markdown文件路径
        output_file_path (str): 输出文件路径
        col_index (int): 要提取链接的列索引
        class_name (str): 要查找的CSS类名
        tag_name (str): 要查找的HTML标签名
        attr_name (str): 要获取的标签属性名
    """
    
    # 先备份原始文件
    import shutil
    shutil.copy(md_file_path, md_file_path + ".backup")
    
    # 追加链接到Markdown文件
    success = append_links_to_markdown(md_file_path, output_file_path, col_index=col_index, 
                                     class_name=class_name, tag_name=tag_name, attr_name=attr_name)
    
    if success:
        print("成功追加链接到Markdown文件")
        # 显示更新后的文件前几行
        with open(output_file_path, 'r', encoding='utf-8') as f:
            lines = f.readlines()
            print("更新后的文件前5行:")
            for i in range(min(5, len(lines))):
                print(lines[i].rstrip())
    else:
        print("追加链接到Markdown文件失败")
    
    # 恢复原始文件
    shutil.move(md_file_path + ".backup", md_file_path)

def extract_github_links_from_tsv(input_file, output_file, col_index=2, contain_txt="github.com"):
    """
    从TSV文件中提取指定列链接，访问链接并查找包含指定文本的href链接，用<br>连接并追加到最后一列
    
    Args:
        input_file (str): 输入的TSV文件路径
        output_file (str): 输出的TSV文件路径
        col_index (int): 要提取链接的列索引，默认为2（第三列）
        contain_txt (str): 要查找的文本内容，默认为"github.com"
        
    Returns:
        bool: 成功返回True，否则返回False
    """
    try:
        # 读取输入文件
        with open(input_file, 'r', encoding='utf-8') as f:
            lines = f.readlines()
        
        # 设置请求头，模拟浏览器访问
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
        }
        
        # 处理每一行
        for i in range(len(lines)):
            # 跳过标题行
            if i == 0:
                # 在标题行添加新的列标题
                lines[i] = lines[i].rstrip('\n') + f'\t包含{contain_txt}的链接\n'
                continue
            
            # 分割行数据
            parts = lines[i].rstrip('\n').split('\t')
            
            # 确保有足够的列
            if len(parts) > col_index:
                # 获取指定列的链接
                target_link = parts[col_index].strip()
                
                # 如果指定列有链接
                if target_link:
                    print(f"正在处理链接: {target_link}")
                    
                    try:
                        # 访问链接页面
                        response = requests.get(target_link, headers=headers, timeout=10)
                        response.encoding = 'utf-8'
                        
                        # 使用BeautifulSoup解析HTML
                        soup = BeautifulSoup(response.text, 'html.parser')
                        
                        # 查找所有a标签
                        a_tags = soup.find_all('a')
                        
                        # 查找包含指定文本的href链接
                        found_links = []
                        for a_tag in a_tags:
                            href = a_tag.get('href')
                            if href and contain_txt in href:
                                found_links.append(href)
                                print(f"找到{contain_txt}链接: {href}")
                        
                        # 如果找到了链接，用<br>连接并追加到最后一列
                        if found_links:
                            # 用<br>连接所有找到的链接
                            github_links = "<br>".join(found_links)
                            
                            # 如果行数据列数不足col_index+2列，需要添加空列
                            while len(parts) < col_index + 2:
                                parts.append("")
                            
                            # 设置最后一列的值
                            parts[col_index + 1] = github_links
                        else:
                            # 如果没找到链接，确保最后一列为空
                            while len(parts) < col_index + 2:
                                parts.append("")
                            parts[col_index + 1] = ""
                        
                        # 重新组合行数据
                        lines[i] = '\t'.join(parts) + '\n'
                        
                    except Exception as e:
                        print(f'访问链接时发生错误: {str(e)}')
                        # 确保有足够的列
                        while len(parts) < col_index + 2:
                            parts.append("")
                        parts[col_index + 1] = ""
                        lines[i] = '\t'.join(parts) + '\n'
                        
                    # 添加延时，避免请求过于频繁
                    time.sleep(1)
                else:
                    # 如果指定列没有链接，确保最后一列为空
                    while len(parts) < col_index + 2:
                        parts.append("")
                    parts[col_index + 1] = ""
                    lines[i] = '\t'.join(parts) + '\n'
            else:
                # 如果列数不足，确保有足够的列
                while len(parts) < col_index + 2:
                    parts.append("")
                lines[i] = '\t'.join(parts) + '\n'
        
        # 写入修改后的内容到输出文件
        with open(output_file, 'w', encoding='utf-8') as f:
            f.writelines(lines)
            
        print(f"已将结果保存到 {output_file}")
        return True
        
    except Exception as e:
        print(f'处理TSV文件时发生错误: {str(e)}')
        return False

def test_extract_github_links(input_file = "input_files/rss_link.txt",output_file = "input_files/rss_link_add_github.txt"):
    """
    测试extract_github_links_from_tsv函数
    """
    
    
    # 使用默认参数（第三列，查找github.com链接）
    success = extract_github_links_from_tsv(input_file, output_file)
    
    if success:
        print("成功提取GitHub链接并保存到文件")
        # 显示输出文件的内容
        with open(output_file, 'r', encoding='utf-8') as f:
            lines = f.readlines()
            print("输出文件内容:")
            for line in lines:
                print(line.rstrip())
    else:
        print("提取GitHub链接失败")

if __name__ == '__main__':
    # test_get_links()
    # txtcol2emptyfile()
    # test_link2txt()
    # test_extract_links()
    # test_extract_pdf_links()
    # test_append_links()
    # test_extract_github_links()
    extract_github_links_from_tsv(input_file = "input_files/rss_link.txt",output_file = "input_files/rss_link_add_github.txt", col_index=2, contain_txt="github.com")
    pass

